﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SST_DA;
using System.Data;

namespace SST_BL
{
    public class MainBL
    {

        //***************************//
        //********Base de datos******//
        //***************************//

        public static bool RevisarConexionBaseDatos() {
            return BDDA.RevisarConexionBaseDatos();
        }//public static bool RevisarConexionBaseDatos() { 
        
        
        //**************************//
        //********Rol********//
        //**************************//

        public static bool RevisarPermiso(string usuario, string permiso) {
            return RolBL.RevisarPermiso(usuario, permiso);
        }//public static bool RevisarPermiso(string usuario, string permiso) { 

        public static DataTable ListarRoles() {
            return RolesADataTable(RolBL.ListarRoles());
        }//public static DataTable ListarRoles() { 

        public static void RevisarRoles() {
            RolBL.RevisarRoles();
        }//public static void RevisarRoles() { 

        public static bool AgregarRol(string nombre) {
            return RolBL.AgregarRol(nombre);
        }//public static bool AgregarRol(string nombre) { 

        public static DataTable RolesADataTable(Rol[] roles) {
            DataTable dt = new DataTable();

            dt.Columns.Add("ID", typeof(int));
            dt.Columns.Add("Nombre", typeof(string));

            for (int i = 0; i < roles.Length; i++ )
            {
                dt.Rows.Add(roles[i].RolID, roles[i].NombreRol);
            }
            return dt;
        }//


        public static bool EditarRol(int id, string nombre)
        {
            return RolBL.EditarRol(id, nombre);
        }//public static void EditarRol(int id, string nombre)

        public static bool EliminarRol(int id)
        {
            return RolBL.EliminarRol(id);
        }

        //**************************//
        //********Coordinador*******//
        //**************************//

        public static bool CambiarCoordinadorDeCircuito(int InformaticoID, int CircuitoID)
        {
            return InformaticoBL.CambiarCoordinadorDeCircuito(InformaticoID, CircuitoID);
        }//public static bool CambiarCoordinadorDeCircuito(int CircuitoID, int InformaticoID) { 

        //**************************//
        //********Informatico********//
        //**************************//

        public static DataTable ListarInformaticos(string InformaticoActual = null) {
            return InformaticosToDataTable(InformaticoBL.ListarInformaticos(), InformaticoActual);
        }//public static Informatico[] ListarInformaticos() { 

        public static DataTable ListarInformaticosPorCircuito(int Circuito, string InformaticoActual = null)
        {
            return InformaticosToDataTable(InformaticoBL.ListarInformaticosPorCircuito(new int[] { Circuito }), InformaticoActual);
        }//public static DataTable ListarInformaticosPorCircuito() { 

        public static DataTable ListarInformaticosPorCircuito(int[] Circuitos, string InformaticoActual = null)
        {
            return InformaticosToDataTable(InformaticoBL.ListarInformaticosPorCircuito(Circuitos), InformaticoActual);
        }//public static DataTable ListarInformaticosPorCircuito() { 

        public static DataTable ListarInformaticosDeCooridador(string username) {
            if(username.Equals(""))
                return null;
            Informatico i = GetInformatico(username);
            if(i == null)
                return null;
            return ListarInformaticosPorCircuito(i.Circuitos);
        }//public static DataTable ListarInformaticosDeCooridador(string username) { 

        public static DataTable ListarCoordinadoresDeTI() {
            return InformaticoBL.ListarCoordinadorDeTI();
        }//public static DataTable ListarCoordinadoresDeTI() {
        
        public static DataTable InformaticosToDataTable(Informatico[] informaticos, string InformaticoActual)
        {
            if (informaticos.Length != 0) {
                DataTable dt = new DataTable();
                dt.Columns.Add("ID", typeof(int));
                dt.Columns.Add("Nombre", typeof(string));
                dt.Columns.Add("Rol", typeof(string));
                dt.Columns.Add("Circuito", typeof(string));
                dt.Columns.Add("Horario", typeof(string));
                for (int i = 0; i < informaticos.Length; i++)
                {
                    Horario h = GetHorario(informaticos[i].Horario);
                    string dias = "";
                    string horarioConFormato = "";
                    if (h != null) {
                        dias = DiasBoolToString(h.Dias);                     
                        horarioConFormato = h.NombreHorario + "  | Hora Inicio: " + (h.HoraInicio / 60) + ":00 | Hora Fin: " + (h.HoraFin / 60) + ":00 | Dias de trabajo: " + dias;                        
                    }//if h != null
                    dt.Rows.Add(informaticos[i].InformaticoID, informaticos[i].NombreInformatico, informaticos[i].NombreRol, GetNombreCircuito(informaticos[i].Circuitos), horarioConFormato);
                }//for (int i = 0; i < informaticos.Length; i++)
                return dt;
            }// if (informaticos.Length != 0) {
            return null;
        }//public static DataTable InformaticosToDataTable(Informatico[] informaticos) { 

        public static bool AgregarInformatico(string nombre, string rol, int[] circuitos, int horario)
        {
            if (nombre != null && !nombre.Equals("") && !rol.Equals("") && horario != 0)
                return InformaticoBL.AgregarInformatico(new Informatico(nombre, rol, circuitos, horario));
            return false;
        }//public static bool AgregarInformatico(string nombre)

        public static bool EditarInformatico(int InformaticoID, string NombreInformatico, string NombreRol, int[] circuitos, int HorarioID)
        {
            return InformaticoBL.EditarInformatico(new Informatico(InformaticoID, NombreInformatico, NombreRol, circuitos, HorarioID));
        }//public static void EditarInformatico(int InformaticoID, string NombreInformatico)

        public static bool EliminarInformatico(int id)
        {
            return InformaticoBL.EliminarInformatico(id);
        }//public static bool EliminarInformatico(int id)

        public static Informatico GetInformatico(int id) {
            return InformaticoBL.GetInformatico(id);
        }

        public static bool ExisteInformatico(string nombre) {
            return InformaticoBL.GetInformatico(nombre) != null;
        }//public static bool ExisteInformatico() { 

        public static string GetNombreInformatico(int id) {
            return InformaticoBL.GetInformatico(id).NombreInformatico;
        }//public static string GetNombreInformatico() { 

        public static string GetRolInformatico(int id) {
            return InformaticoBL.GetInformatico(id).NombreRol;
        }//public static string GetRolInformatico(int id) { 

        public static int[] GetCircuitoInformatico(int id)
        {
            return InformaticoBL.GetInformatico(id).Circuitos;
        }//public static string GetRolInformatico(int id) { 

        public static int[] GetCircuitoInformatico(string username)
        {
            return InformaticoBL.GetInformatico(username).Circuitos;
        }//public static string GetRolInformatico(int id) { 

        public static bool IsCoordinadorTI(string username) {
            Informatico i = GetInformatico(username);
            if (i == null)
                return false;
            return InformaticoBL.IsCoordinador(i.InformaticoID);
        }//public static bool IsCoordinadorTI(string username) { 

        public static bool IsCoordinadorTI(int InformaticoID)
        {
            return InformaticoBL.IsCoordinador(InformaticoID);
        }//public static bool IsCoordinadorTI(string username) { 

       
        public static Informatico GetInformatico(string nombre) {
            return InformaticoBL.GetInformatico(nombre);
        }//public static Informatico GetInformatico(string nombre) { 

        public static int GetInformaticoID(string nombre) {
            return InformaticoBL.GetInformatico(nombre).InformaticoID;
        }//public static int GetInformaticoID(string nombre) { 

        //**************************//
        //********Habilidades********//
        //**************************//

        public static DataTable ListarHabilidades() {
            return HabilidadesToDataTable(HabilidadBL.ListarHabilidades());
        }//public static HabilidadBL[] ListarHabilidades() { 

        public static DataTable ListarHabiliadesPorCircuito(int[] Circuitos) {
            return HabilidadesToDataTable(HabilidadBL.ListarHabilidadesPorCircuito(Circuitos));
        }//public static DataTable ListarHabiliadesPorCircuito() { 

        public static DataTable HabilidadesToDataTable(Habilidad[] Habilidades)
        {
            if (Habilidades.Length != 0)
            {
                DataTable dt = new DataTable();
                dt.Columns.Add("ID", typeof(int));
                dt.Columns.Add("Nombre", typeof(string));
                dt.Columns.Add("Circuito", typeof(string));
                for (int i = 0; i < Habilidades.Length; i++)
                {
                    dt.Rows.Add(Habilidades[i].getHabilidadID(), Habilidades[i].NombreHabilidad, CircuitoBL.GetCircuito(Habilidades[i].CircuitoID).nombreCircuito);
                }//for (int i = 0; i < informaticos.Length; i++)
                return dt;
            }// if (informaticos.Length != 0) {
            return null;
        }//public static DataTable InformaticosToDataTable(Informatico[] informaticos) { 

        public static DataTable GetHabilidadesDeInformatico(int Informatico) {
            return HabilidadBL.GetHabilidadesDeInformatico(Informatico);
        }//public static DataTable GetHabilidadesDeInformatico(string NombreInformatico) { 

        public static int GetCircuitoHabilidad(int id) {
            return HabilidadBL.GetHabilidad(id).CircuitoID;
        }//public static string GetCircuitoHabilidad() { 

        public static bool AgregarHabilidad(string nombre, int CircuitoID) {         
            return HabilidadBL.AgregarHabilidad(nombre, CircuitoID);
        }//public static bool AgregarHabilidad(string nombre) { 

        public static bool ExisteHabilidad(string nombre, int CircuitoID)
        {
            Habilidad h = HabilidadBL.GetHabilidad(nombre);            
            if (h == null)
                return false;
            if (h.CircuitoID != CircuitoID)
                return false;
            return true;
        }//public static bool ExisteHabilidad(string nombre)

        public static bool EliminarHabilidad(int id) {
            return HabilidadBL.EliminarHabilidad(id);
        }//public static bool EliminarHabilidad() { 

        public static bool ModificarHabilidad(int id, string nombre, int circuito)
        {
            return HabilidadBL.ModificarHabilidad(id, nombre, circuito);
        }//public static void EditarHabilidad(int id, string nombre)

        public static bool InformaticoTieneHabilidad(string InformaticoNombre, string NombrehHabilidad)
        {
            return HabilidadBL.InformaticoTieneHabilidad(InformaticoNombre, NombrehHabilidad);
        }//public static bool InformaticoTieneHabilidad(string p)

        public static bool AgregarHabilidadAInformatico(int InformaticoID, int HabilidadID) {
            if (HabilidadID > 0 && InformaticoID > 0)
            {
                return HabilidadBL.AgregarHabilidadAInformatico(InformaticoID, HabilidadID);
            }//if(h != null && i != null){
            return false;
        }//public static bool AgregarHabilidadAInformatico(string NombreInformatico, string NombreHabilidad) { 

        public static bool EliminarHabilidadDeInformatico(string NombreInformatico, string NombreHabilidad)
        {
            return HabilidadBL.EliminarHabilidadDeInformatico(NombreInformatico, NombreHabilidad);
        }//public static bool EliminarHabilidadDeInformatico(string NombreInformatico, string NombreHabilidad)

        public static DataTable HabilidadesPorCircuitoEnBaseAUsuario(int username) {
            Informatico i = GetInformatico(username);
            return ListarHabiliadesPorCircuito(i.Circuitos);
        }//public static DataTable HabilidadesPorCircuito() { 

        public static bool IsHabilidadEnCircuito(int CircuitoID, int HabilidadID) {
            return HabilidadBL.IsHabilidadEnCircuito(CircuitoID, HabilidadID);
        }//public static bool IsHabilidadEnCircuito(int CircuitoID, int HabilidadID) { 

        //**************************//
        //********Circuito********//
        //**************************//

        public static bool ExistenCircuitosEnBD()
        {
            int count = CircuitoBL.ListarCircuitos().Length;
            if (count > 0)
                return true;
            return false;
        }//public static bool ExistenCircuitosEnBD() { 

        public static bool AgregarCircuito(string nombre, string codigo){
            if (nombre.Equals("") || codigo.Equals(""))
                return false;
            if (ExisteCircuito(nombre, codigo))
                return false;
            return CircuitoBL.AgregarCircuito(new Circuito(nombre, codigo));
        }//public static bool AgregarCircuito(){
        
        public static DataTable ListarCircuitos() {
            return CircuitosADataTable(CircuitoBL.ListarCircuitos());
        }//public static DataTable ListarCircuitos() { 

        private static DataTable CircuitosADataTable(Circuito[] circuitos)
        {
            if (circuitos.Length != 0)
            {
                DataTable dt = new DataTable();
                dt.Columns.Add("ID", typeof(int));
                dt.Columns.Add("NombreCircuito", typeof(string));
                dt.Columns.Add("Codigo Circuito", typeof(string));
                for (int i = 0; i < circuitos.Length; i++)
                {
                    dt.Rows.Add(circuitos[i].circuitoID, circuitos[i].nombreCircuito, circuitos[i].codigoCircuito);
                }//for (int i = 0; i < informaticos.Length; i++)
                return dt;
            }
            return null;
        }//private DataTable CircuitosADataTable() { 

        public static bool ExisteCircuito(string nombre, string codigo) {
            return CircuitoBL.GetCircuito(nombre, codigo) != null;
        }//public static bool GetCircuito() { 

        /*public static bool ExisteCircuito(int id)
        {
            return CircuitoBL.GetCircuito(id) != null;
        }//public static bool GetCircuito() {*/

        public static bool ExisteCircuito(int[] ids)
        {
            bool existe = false;
            for(int i = 0; i < ids.Length; i++)
                if(CircuitoBL.GetCircuito(ids[i]) != null)
                    existe = true;
            return existe;
        }//public static bool GetCircuito() {

        public static bool EliminarCircuito(int id) {
            return CircuitoBL.EliminarCircuito(id);
        }//public static bool EliminarCircuito(int id) { 

        public static bool EditarCircuito(int id, string nombre, string codigo) {
            return CircuitoBL.EditarCircuito(id, nombre, codigo);
        }//public static bool EditarCircuito() { 


        public static bool ExisteCircuitoParaEditar(int id, string nombre, string codigo)
        {
            Circuito c = CircuitoBL.GetCircuito(nombre, codigo);
            if (c == null)
                return false;
            if (c.circuitoID == id)
                return false;
            return c != null;            
        }//public static bool ExisteCircuitoParaEditar(string nombre, string codigo)

        /*public static string GetNombreCircuito(int id) {
            Circuito c = CircuitoBL.GetCircuito(id);
            if (c == null)
                return "";
            return c.nombreCircuito;
        }//public static string GetNombreCircuito(int id) { */

        public static string GetNombreCircuito(int[] ids)
        {
            string nombreCircuitos = "";
            for (int i = 0; i < ids.Length; i++ )
            {
                Circuito c = CircuitoBL.GetCircuito(ids[i]);
                if (c != null)
                    nombreCircuitos += c.nombreCircuito+", ";
            }

            return nombreCircuitos;
        }//public static string GetNombreCircuito(int id) {

        public static int GetIDCircuito(string nombre) {
            Circuito c = CircuitoBL.GetCircuito(nombre);
            if (c == null)
                return -1;
            return c.circuitoID;
        }//public static string GetIDCircuito(string nombre) { 
        
        //**************************//
        //********Asignacion********//
        //**************************//

        public static bool getAsignacion(int CircuitoID, int HabilidadID, string realizadaPor){
            if (!IsHabilidadEnCircuito(CircuitoID, HabilidadID))
                return false;
            int informatico =  AsignacionBL.getInformaticoParaAsignar(CircuitoID, HabilidadID);
            int realizadaPorID = GetInformatico(realizadaPor).InformaticoID;
            if (informatico == -1)
                return false;
            return AsignacionBL.AgregarAsignacion(informatico, CircuitoID, HabilidadID, realizadaPorID);
        }//public static getAsignacion(int CircuitoID, int HabilidadID){

        public static DataTable getUltimasAsignaciones(string informatico){
            return AsignacionBL.GetUltimasAsignaciones(GetInformatico(informatico).InformaticoID);
        }//public static getUltimasAsignaciones(int informatico){

        public static DataTable GetAsignaciones() {           
            return AsignacionBL.GetAsignaciones();
        }//public static DataTable GetUltimasAsignacionesDeInformatico(int InformaticoID) { 

        //**************************//
        //********Excepcion********//
        //**************************//

        public static DataTable ListarExcepciones() {
            return ExcepcionesADataTable(ExcepcionBL.ListarExcepciones());
        }

        private static DataTable ExcepcionesADataTable(Excepcion[] excepciones)
        {
            if (excepciones == null)
                return null;
            if (excepciones.Length != 0)
            {
                DataTable dt = new DataTable();
                dt.Columns.Add("ExcepcionID", typeof(int));
                dt.Columns.Add("Informatico", typeof(string));
                dt.Columns.Add("Comienzo", typeof(string));
                dt.Columns.Add("HoraTiempo", typeof(string));
                for (int i = 0; i < excepciones.Length; i++)
                {
                    Informatico info = GetInformatico(excepciones[i].Informatico);
                    if(info != null)                            
                        dt.Rows.Add(
                            excepciones[i].ExcepcionID
                            ,info.NombreInformatico
                            ,excepciones[i].comienzo.ToString()
                            ,excepciones[i].fin.ToString()
                            );
                }//for (int i = 0; i < informaticos.Length; i++)
                return dt;
            }
            return null;
        }//private DataTable CircuitosADataTable() { 

        public static bool AgregarExcepcion(int InformaticoID, DateTime comienzo, DateTime fin) {
            if (InformaticoID == 0 || comienzo == null || fin == null)
                return false;
            if(DateTime.Now > comienzo || DateTime.Now >  fin)
                return false;
            return ExcepcionBL.AgregarExcepcion(new Excepcion(InformaticoID, comienzo, fin));            
        }

        public static bool BorrarExcepcion(int ExcepcionID) {
            return ExcepcionBL.BorrarExcepcion(ExcepcionID);
        }

        //**************************//
        //********Horario***********//
        //**************************//

        public static bool ExistenHorariosEnBD() {
            DataTable horarios = ListarHorarios();
            if(horarios == null || horarios.Rows.Count == 0)
                return false;
            return true;            
        }

        public static DataTable ListarHorarios() { 
            return HorariosADataTable(HorarioBL.ListarHorarios());
        }

        private static DataTable HorariosADataTable(Horario[] horarios) {
            if (horarios == null)
                return null;
            if (horarios.Length != 0)
            {
                DataTable dt = new DataTable();
                dt.Columns.Add("HorarioID", typeof(int));
                dt.Columns.Add("NombreHorario", typeof(string));
                dt.Columns.Add("HoraInicio", typeof(string));
                dt.Columns.Add("HoraFin", typeof(string));
                dt.Columns.Add("Dias", typeof(string));
                for (int i = 0; i < horarios.Length; i++)
                {
                    dt.Rows.Add(
                        horarios[i].HorarioID,
                        horarios[i].NombreHorario,
                        (horarios[i].HoraInicio/60)+":"+(horarios[i].HoraInicio%60).ToString("00"),
                        (horarios[i].HoraFin / 60) + ":" + (horarios[i].HoraFin % 60).ToString("00"),
                        DiasBoolToString(horarios[i].Dias)
                        );
                }//for (int i = 0; i < informaticos.Length; i++)
                return dt;
            }
            return null;
        }

        private static string DiasBoolToString(bool[] dias) {              
            string diasConFormato = "";
            for (int j = 0; j < dias.Length; j++)
            {
                switch (j)
                {
                    case 0:
                        if (dias[j] == true)
                            diasConFormato += "L";
                        break;
                    case 1:
                        if (dias[j] == true)
                            diasConFormato += "K";
                        break;
                    case 2:
                        if (dias[j] == true)
                            diasConFormato += "M";
                        break;
                    case 3:
                        if (dias[j] == true)
                            diasConFormato += "J";
                        break;
                    case 4:
                        if (dias[j] == true)
                            diasConFormato += "V";
                        break;
                    case 5:
                        if (dias[j] == true)
                            diasConFormato += "S";
                        break;
                    case 6:
                        if (dias[j] == true)
                            diasConFormato += "D";
                        break;
                }//swjtch
            }
                return diasConFormato;
        }

        public static Horario GetHorario(int ID) {
            if (ID == 0)
                return null;
            return HorarioBL.GetHorario(ID);
        }

        public static bool[] GetHorarioDias(int ID) {
            if (ID == 0)
                return null;
            return HorarioBL.GetHorario(ID).Dias;
        }

        /// <summary>
        /// Esta funcion revisar un bool[], para que no todos sean false.
        /// </summary>
        /// <param name="list">bool[]</param>
        /// <returns>true si hay algun check box marcado, false de lo contrario</returns>
        private static  bool RevisarBool(bool[] boolList)
        {
            for (int i = 0; i < boolList.Length; i++)
                if (boolList[i] == true)
                    return true;
            return false;
        }

        public static bool AgregarHorario(string nombreHorario, int HoraInicio, int HoraFin, bool[] dias) {
            if (!nombreHorario.Equals("") && HoraInicio != 0 && HoraFin != 0 && RevisarBool(dias))
                if(HoraInicio < HoraFin)
                    return HorarioBL.AgregarHorario(new Horario(nombreHorario, HoraInicio, HoraFin, dias));
            return false;
        }

        public static bool EditarHorario( int HorarioID, string nombreHorario, int HoraInicio, int HoraFin, bool[] dias) {
            if (!nombreHorario.Equals("") && HoraInicio != 0 && HoraFin != 0 && RevisarBool(dias))
                if (HoraInicio < HoraFin)
                    return HorarioBL.EditarHorario(new Horario(HorarioID, nombreHorario, HoraInicio, HoraFin, dias));
            return false;
        }

        public static bool EliminarHorario(int HorarioID) {
            if (HorarioID < 0)
                return false;
            return HorarioBL.EliminarHorario(HorarioID);
        }

        //**************************//
        //*********Perfil***********//
        //**************************//

        public static DataTable InformacionPerfil(int InformaticoID) {            
            DataTable dt = new DataTable();
            dt.Columns.Add("Nombre", typeof(string));
            dt.Columns.Add("Valor", typeof(string));
            Informatico i = GetInformatico(InformaticoID);
            if (i == null)
                return null;
            dt.Rows.Add("Nombre ", i.InformaticoID);
            //--------------------------------------------------------------------//
            dt.Rows.Add("Circuito",GetNombreCircuito(GetCircuitoInformatico(InformaticoID)));
            //--------------------------------------------------------------------//                    
            dt.Rows.Add("Rol", GetRolInformatico(InformaticoID));
            //--------------------------------------------------------------------//
            if(i.Horario != 0){
                Horario h = GetHorario(i.Horario);
                dt.Rows.Add("Horario", "");
                dt.Rows.Add("    Nombre Horario", h.NombreHorario);
                dt.Rows.Add("    HoraInicio", (h.HoraInicio / 60) + ":00");
                dt.Rows.Add("    HoraFin", (h.HoraFin / 60) + ":00");
                dt.Rows.Add("    Dias de Trabajo", DiasBoolToString(h.Dias));
            }            
           //--------------------------------------------------------------------//
            if(i.NombreRol == "Personal de Soporte"){                
                DataTable habilidades = GetHabilidadesDeInformatico(InformaticoID);
                dt.Rows.Add("Habilidades", "");
                for(int j = 0; j < habilidades.Rows.Count; j++)
                    dt.Rows.Add("    ", habilidades.Rows[j].ItemArray[0].ToString());                
            }
           //--------------------------------------------------------------------//
            return dt;
        }


    }//public class MainBL
}//namespace SST_BL
